/**
 * MobX页面绑定通用模板
 * 各业务页面可以参考此模板实现与Store的绑定
 */

// 引入MobX绑定工具
const mobx = require('../../../../framework/mobx/mobx_wx.js');
const pageHelper = require('../../modules/research/helpers/page_helper.js');
const cloudHelper = require('../../../../helpers/cloud_helper.js');
const dataHelper = require('../../../../helpers/data_helper.js');
const timeHelper = require('../../../../helpers/time_helper.js');
const validate = require('../../../../helpers/validate.js');
const setting = require('../../../../setting/setting.js');
const Day = require('../../../../framework/day/day.js');

// 缓存KEY
const CACHE_TASK_INDEX = 'TASK_INDEX_CACHE';
const CACHE_TASK_TIME = 30 * 60 * 1000; // 缓存30分钟有效

// 示例Store导入 - 实际使用时替换为对应模块的Store
const TaskStore = require('../../../../store/task_store.js');

// 页面配置
Page({
  /**
   * 页面的初始数据
   */
  data: {
    // UI状态
    isLoading: true,     // 页面数据加载中
    isLoadingMore: false, // 加载更多中
    isRefreshing: false,  // 下拉刷新中
    isEmpty: false,      // 数据列表是否为空
    
    // 分页参数
    page: 1,             // 当前页码
    pageSize: 20,        // 每页记录数
    totalCount: 0,       // 总记录数
    hasMore: true,       // 是否还有更多数据
    
    // 查询条件
    searchKey: '',       // 搜索关键词
    sortType: 'time',    // 排序方式 time/status
    sortDir: 'desc',     // 排序方向 asc/desc
    status: -1,          // 筛选状态 -1全部/0待处理/1已完成
    
    // 本地数据
    taskList: [],        // 任务列表数据
    
    // MobX Store数据 - 将通过storeBindings绑定
    storeTaskCount: 0,
    storeUrgentTasks: [],
    storeCompletedRate: 0
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad: async function(options) {
    // 创建MobX Store绑定
    this.storeBindings = mobx.createStoreBindings(this, {
      store: TaskStore,
      fields: {
        storeTaskCount: 'taskCount',
        storeUrgentTasks: 'urgentTasks',
        storeCompletedRate: 'completedRate'
      },
      actions: ['incrementTaskCount', 'addTask', 'removeTask', 'updateTaskStatus', 'loadTaskList']
    });

    // 处理页面传参
    if (options) {
      // 处理从其他页面跳转时携带的参数
      this._handlePageOptions(options);
    }

    // 初始化页面数据
    await this._initData();
  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload: function() {
    // 解除MobX绑定
    this.storeBindings.destroyStoreBindings();
  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh: async function() {
    try {
      this.setData({
        isRefreshing: true,
        page: 1,
        hasMore: true
      });
      
      await this._loadTaskList(true);
      
      // 通知Store重新加载数据
      this.loadTaskList();
      
      wx.stopPullDownRefresh();
    } catch (err) {
      console.error('下拉刷新失败', err);
    } finally {
      this.setData({
        isRefreshing: false
      });
    }
  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom: async function() {
    // 已无更多数据，不处理
    if (!this.data.hasMore) return;
    
    try {
      this.setData({
        isLoadingMore: true
      });
      
      const nextPage = this.data.page + 1;
      this.setData({
        page: nextPage
      });
      
      await this._loadTaskList(false);
    } catch (err) {
      console.error('触底加载失败', err);
    } finally {
      this.setData({
        isLoadingMore: false
      });
    }
  },

  /**
   * 处理页面传参
   */
  _handlePageOptions: function(options) {
    // 处理从其他页面传入的参数
    if (options.status !== undefined) {
      // 设置状态筛选
      this.setData({
        status: parseInt(options.status)
      });
    }
    
    if (options.searchKey) {
      // 设置搜索关键词
      this.setData({
        searchKey: options.searchKey
      });
    }
  },

  /**
   * 初始化页面数据
   */
  _initData: async function() {
    this.setData({
      isLoading: true
    });
    
    try {
      // 优先从缓存加载数据
      await this._loadFromCache();
      
      // 异步刷新数据
      await this._loadTaskList(true);
      
      // 通知Store加载数据
      this.loadTaskList();
    } catch (err) {
      console.error('初始化数据失败', err);
      this.setData({
        isEmpty: true
      });
    } finally {
      this.setData({
        isLoading: false
      });
    }
  },

  /**
   * 从缓存加载数据
   */
  _loadFromCache: async function() {
    // 从缓存读取数据
    const cacheData = wx.getStorageSync(CACHE_TASK_INDEX);
    if (!cacheData) return;
    
    // 检查缓存是否过期
    if (cacheData.time + CACHE_TASK_TIME < Date.now()) {
      // 缓存过期，清除
      wx.removeStorageSync(CACHE_TASK_INDEX);
      return;
    }
    
    // 使用缓存数据
    this.setData({
      taskList: cacheData.list,
      totalCount: cacheData.totalCount,
      page: cacheData.page,
      hasMore: cacheData.hasMore,
      isEmpty: cacheData.list.length === 0
    });
    
    console.log('从缓存加载数据成功');
  },

  /**
   * 保存数据到缓存
   */
  _saveToCache: function() {
    const cacheData = {
      list: this.data.taskList,
      totalCount: this.data.totalCount,
      page: this.data.page,
      hasMore: this.data.hasMore,
      time: Date.now()
    };
    
    wx.setStorageSync(CACHE_TASK_INDEX, cacheData);
  },

  /**
   * 加载任务列表
   * @param {boolean} isRefresh 是否为刷新操作
   */
  _loadTaskList: async function(isRefresh = false) {
    try {
      // 构建查询参数
      const params = {
        page: this.data.page,
        size: this.data.pageSize,
        status: this.data.status,
        sortType: this.data.sortType,
        sortDir: this.data.sortDir,
        keyword: this.data.searchKey
      };
      
      // 调用云函数获取数据
      const result = await cloudHelper.callCloudData('task/list', params);
      
      const list = result.list || [];
      
      // 格式化数据
      for (let i = 0; i < list.length; i++) {
        list[i].TASK_ADD_TIME_SHOW = timeHelper.timestamp2Time(list[i].TASK_ADD_TIME);
        list[i].TASK_LAST_TIME_SHOW = timeHelper.timestamp2Time(list[i].TASK_LAST_TIME);
        
        // 使用Day.js处理日期
        const deadlineDay = Day(list[i].TASK_DEADLINE);
        list[i].TASK_DEADLINE_DAY = deadlineDay.format('YYYY-MM-DD');
        list[i].TASK_DEADLINE_TIME = deadlineDay.format('HH:mm');
        
        // 计算剩余天数
        const today = Day();
        const diffDays = deadlineDay.diff(today, 'day');
        list[i].TASK_DAYS_LEFT = diffDays;
        list[i].TASK_IS_URGENT = diffDays <= 1 && list[i].TASK_STATUS === 0;
      }
      
      if (isRefresh) {
        // 刷新操作，替换原数据
        this.setData({
          taskList: list,
          totalCount: result.total,
          hasMore: list.length < result.total,
          isEmpty: list.length === 0
        });
      } else {
        // 加载更多，追加数据
        this.setData({
          taskList: this.data.taskList.concat(list),
          totalCount: result.total,
          hasMore: this.data.taskList.length + list.length < result.total
        });
      }
      
      // 保存到缓存
      this._saveToCache();
      
      return result;
    } catch (err) {
      console.error('加载任务列表失败', err);
      throw err;
    }
  },

  /**
   * 搜索任务
   */
  bindSearchInput: function(e) {
    this.setData({
      searchKey: e.detail.value
    });
  },

  bindSearchTap: async function(e) {
    try {
      this.setData({
        page: 1,
        hasMore: true
      });
      
      await this._loadTaskList(true);
    } catch (err) {
      console.error('搜索失败', err);
      pageHelper.showNoneToast('搜索失败');
    }
  },

  /**
   * 切换排序方式
   */
  bindSortTap: async function(e) {
    const type = e.currentTarget.dataset.type;
    
    // 如果点击当前排序方式，则切换排序方向
    if (type === this.data.sortType) {
      this.setData({
        sortDir: this.data.sortDir === 'asc' ? 'desc' : 'asc'
      });
    } else {
      // 切换排序类型，默认降序
      this.setData({
        sortType: type,
        sortDir: 'desc'
      });
    }
    
    try {
      this.setData({
        page: 1,
        hasMore: true
      });
      
      await this._loadTaskList(true);
    } catch (err) {
      console.error('排序失败', err);
      pageHelper.showNoneToast('操作失败');
    }
  },

  /**
   * 切换状态筛选
   */
  bindStatusTap: async function(e) {
    const status = parseInt(e.currentTarget.dataset.status);
    
    this.setData({
      status: status,
      page: 1,
      hasMore: true
    });
    
    try {
      await this._loadTaskList(true);
    } catch (err) {
      console.error('状态筛选失败', err);
      pageHelper.showNoneToast('操作失败');
    }
  },

  /**
   * 点击任务项
   */
  bindItemTap: function(e) {
    const id = e.currentTarget.dataset.id;
    
    // 跳转到任务详情页
    wx.navigateTo({
      url: '../detail/task_detail?id=' + id
    , timeout: 10000, fail: function(err) {
        // 处理超时错误
        if (err.errMsg && err.errMsg.includes("timeout")) {
          wx.showToast({
            title: "页面加载超时，请重试",
            icon: "none"
          });
          return;
        }
        
        // 处理其他错误
        console.error("页面跳转失败:", err);
        wx.showToast({
          title: "页面跳转失败",
          icon: "none"
        });
      }});
  },

  /**
   * 添加任务
   */
  bindAddTap: function() {
    wx.navigateTo({
      url: '../add/task_add'
    , timeout: 10000, fail: function(err) {
        // 处理超时错误
        if (err.errMsg && err.errMsg.includes("timeout")) {
          wx.showToast({
            title: "页面加载超时，请重试",
            icon: "none"
          });
          return;
        }
        
        // 处理其他错误
        console.error("页面跳转失败:", err);
        wx.showToast({
          title: "页面跳转失败",
          icon: "none"
        });
      }});
  },

  /**
   * 更新任务状态
   */
  bindStatusChangeTap: async function(e) {
    const id = e.currentTarget.dataset.id;
    const status = parseInt(e.currentTarget.dataset.status);
    const newStatus = status === 0 ? 1 : 0;
    
    try {
      // 调用云函数更新状态
      await cloudHelper.callCloudData('task/status', {
        id: id,
        status: newStatus
      });
      
      // 更新本地数据
      let taskList = this.data.taskList;
      for (let i = 0; i < taskList.length; i++) {
        if (taskList[i]._id === id) {
          taskList[i].TASK_STATUS = newStatus;
          break;
        }
      }
      
      this.setData({
        taskList: taskList
      });
      
      // 保存到缓存
      this._saveToCache();
      
      // 通知Store更新状态
      this.updateTaskStatus(id, newStatus);
      
      pageHelper.showSuccessToast('状态已更新');
    } catch (err) {
      console.error('更新状态失败', err);
      pageHelper.showModal('操作失败', '请稍后重试');
    }
  },

  /**
   * 删除任务
   */
  bindDeleteTap: async function(e) {
    const id = e.currentTarget.dataset.id;
    
    try {
      // 确认删除
      const confirm = await pageHelper.showConfirm('确认删除', '删除后不可恢复，是否继续？');
      if (!confirm) return;
      
      // 调用云函数删除任务
      await cloudHelper.callCloudData('task/delete', {
        id: id
      });
      
      // 更新本地数据
      let taskList = this.data.taskList;
      const newList = taskList.filter(item => item._id !== id);
      
      this.setData({
        taskList: newList,
        isEmpty: newList.length === 0
      });
      
      // 保存到缓存
      this._saveToCache();
      
      // 通知Store删除任务
      this.removeTask(id);
      
      pageHelper.showSuccessToast('删除成功');
    } catch (err) {
      console.error('删除任务失败', err);
      pageHelper.showModal('删除失败', '请稍后重试');
    }
  }
}); 